home *** CD-ROM | disk | FTP | other *** search
/ PC PowerPlay 58 / pcpp58a.iso / extras / quake 3 source / Q3A_ToolSource.exe / Main / bspfile.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-02  |  14.0 KB  |  544 lines
  1.  
  2. #include "cmdlib.h"
  3. #include "mathlib.h"
  4. #include "bspfile.h"
  5. #include "scriplib.h"
  6.  
  7. void GetLeafNums (void);
  8.  
  9. //=============================================================================
  10.  
  11. int            nummodels;
  12. dmodel_t    dmodels[MAX_MAP_MODELS];
  13.  
  14. int            numShaders;
  15. dshader_t    dshaders[MAX_MAP_SHADERS];
  16.  
  17. int            entdatasize;
  18. char        dentdata[MAX_MAP_ENTSTRING];
  19.  
  20. int            numleafs;
  21. dleaf_t        dleafs[MAX_MAP_LEAFS];
  22.  
  23. int            numplanes;
  24. dplane_t    dplanes[MAX_MAP_PLANES];
  25.  
  26. int            numnodes;
  27. dnode_t        dnodes[MAX_MAP_NODES];
  28.  
  29. int            numleafsurfaces;
  30. int            dleafsurfaces[MAX_MAP_LEAFFACES];
  31.  
  32. int            numleafbrushes;
  33. int            dleafbrushes[MAX_MAP_LEAFBRUSHES];
  34.  
  35. int            numbrushes;
  36. dbrush_t    dbrushes[MAX_MAP_BRUSHES];
  37.  
  38. int            numbrushsides;
  39. dbrushside_t    dbrushsides[MAX_MAP_BRUSHSIDES];
  40.  
  41. int            numLightBytes;
  42. byte        lightBytes[MAX_MAP_LIGHTING];
  43.  
  44. int            numGridPoints;
  45. byte        gridData[MAX_MAP_LIGHTGRID];
  46.  
  47. int            numVisBytes;
  48. byte        visBytes[MAX_MAP_VISIBILITY];
  49.  
  50. int            numDrawVerts;
  51. drawVert_t    drawVerts[MAX_MAP_DRAW_VERTS];
  52.  
  53. int            numDrawIndexes;
  54. int            drawIndexes[MAX_MAP_DRAW_INDEXES];
  55.  
  56. int            numDrawSurfaces;
  57. dsurface_t    drawSurfaces[MAX_MAP_DRAW_SURFS];
  58.  
  59. int            numFogs;
  60. dfog_t        dfogs[MAX_MAP_FOGS];
  61.  
  62. //=============================================================================
  63.  
  64. /*
  65. =============
  66. SwapBlock
  67.  
  68. If all values are 32 bits, this can be used to swap everything
  69. =============
  70. */
  71. void SwapBlock( int *block, int sizeOfBlock ) {
  72.     int        i;
  73.  
  74.     sizeOfBlock >>= 2;
  75.     for ( i = 0 ; i < sizeOfBlock ; i++ ) {
  76.         block[i] = LittleLong( block[i] );
  77.     }
  78. }
  79.  
  80. /*
  81. =============
  82. SwapBSPFile
  83.  
  84. Byte swaps all data in a bsp file.
  85. =============
  86. */
  87. void SwapBSPFile( void ) {
  88.     int                i;
  89.     
  90.     // models    
  91.     SwapBlock( (int *)dmodels, nummodels * sizeof( dmodels[0] ) );
  92.  
  93.     // shaders (don't swap the name)
  94.     for ( i = 0 ; i < numShaders ; i++ ) {
  95.         dshaders[i].contentFlags = LittleLong( dshaders[i].contentFlags );
  96.         dshaders[i].surfaceFlags = LittleLong( dshaders[i].surfaceFlags );
  97.     }
  98.  
  99.     // planes
  100.     SwapBlock( (int *)dplanes, numplanes * sizeof( dplanes[0] ) );
  101.     
  102.     // nodes
  103.     SwapBlock( (int *)dnodes, numnodes * sizeof( dnodes[0] ) );
  104.  
  105.     // leafs
  106.     SwapBlock( (int *)dleafs, numleafs * sizeof( dleafs[0] ) );
  107.  
  108.     // leaffaces
  109.     SwapBlock( (int *)dleafsurfaces, numleafsurfaces * sizeof( dleafsurfaces[0] ) );
  110.  
  111.     // leafbrushes
  112.     SwapBlock( (int *)dleafbrushes, numleafbrushes * sizeof( dleafbrushes[0] ) );
  113.  
  114.     // brushes
  115.     SwapBlock( (int *)dbrushes, numbrushes * sizeof( dbrushes[0] ) );
  116.  
  117.     // brushsides
  118.     SwapBlock( (int *)dbrushsides, numbrushsides * sizeof( dbrushsides[0] ) );
  119.  
  120.     // vis
  121.     ((int *)&visBytes)[0] = LittleLong( ((int *)&visBytes)[0] );
  122.     ((int *)&visBytes)[1] = LittleLong( ((int *)&visBytes)[1] );
  123.  
  124.     // drawverts (don't swap colors )
  125.     for ( i = 0 ; i < numDrawVerts ; i++ ) {
  126.         drawVerts[i].lightmap[0] = LittleFloat( drawVerts[i].lightmap[0] );
  127.         drawVerts[i].lightmap[1] = LittleFloat( drawVerts[i].lightmap[1] );
  128.         drawVerts[i].st[0] = LittleFloat( drawVerts[i].st[0] );
  129.         drawVerts[i].st[1] = LittleFloat( drawVerts[i].st[1] );
  130.         drawVerts[i].xyz[0] = LittleFloat( drawVerts[i].xyz[0] );
  131.         drawVerts[i].xyz[1] = LittleFloat( drawVerts[i].xyz[1] );
  132.         drawVerts[i].xyz[2] = LittleFloat( drawVerts[i].xyz[2] );
  133.         drawVerts[i].normal[0] = LittleFloat( drawVerts[i].normal[0] );
  134.         drawVerts[i].normal[1] = LittleFloat( drawVerts[i].normal[1] );
  135.         drawVerts[i].normal[2] = LittleFloat( drawVerts[i].normal[2] );
  136.     }
  137.  
  138.     // drawindexes
  139.     SwapBlock( (int *)drawIndexes, numDrawIndexes * sizeof( drawIndexes[0] ) );
  140.  
  141.     // drawsurfs
  142.     SwapBlock( (int *)drawSurfaces, numDrawSurfaces * sizeof( drawSurfaces[0] ) );
  143.  
  144.     // fogs
  145.     for ( i = 0 ; i < numFogs ; i++ ) {
  146.         dfogs[i].brushNum = LittleLong( dfogs[i].brushNum );
  147.         dfogs[i].visibleSide = LittleLong( dfogs[i].visibleSide );
  148.     }
  149. }
  150.  
  151.  
  152.  
  153. /*
  154. =============
  155. CopyLump
  156. =============
  157. */
  158. int CopyLump( dheader_t    *header, int lump, void *dest, int size ) {
  159.     int        length, ofs;
  160.  
  161.     length = header->lumps[lump].filelen;
  162.     ofs = header->lumps[lump].fileofs;
  163.     
  164.     if ( length % size ) {
  165.         Error ("LoadBSPFile: odd lump size");
  166.     }
  167.  
  168.     memcpy( dest, (byte *)header + ofs, length );
  169.  
  170.     return length / size;
  171. }
  172.  
  173. /*
  174. =============
  175. LoadBSPFile
  176. =============
  177. */
  178. void    LoadBSPFile( const char *filename ) {
  179.     dheader_t    *header;
  180.  
  181.     // load the file header
  182.     LoadFile (filename, (void **)&header);
  183.  
  184.     // swap the header
  185.     SwapBlock( (int *)header, sizeof(*header) );
  186.  
  187.     if ( header->ident != BSP_IDENT ) {
  188.         Error( "%s is not a IBSP file", filename );
  189.     }
  190.     if ( header->version != BSP_VERSION ) {
  191.         Error( "%s is version %i, not %i", filename, header->version, BSP_VERSION );
  192.     }
  193.  
  194.     numShaders = CopyLump( header, LUMP_SHADERS, dshaders, sizeof(dshader_t) );
  195.     nummodels = CopyLump( header, LUMP_MODELS, dmodels, sizeof(dmodel_t) );
  196.     numplanes = CopyLump( header, LUMP_PLANES, dplanes, sizeof(dplane_t) );
  197.     numleafs = CopyLump( header, LUMP_LEAFS, dleafs, sizeof(dleaf_t) );
  198.     numnodes = CopyLump( header, LUMP_NODES, dnodes, sizeof(dnode_t) );
  199.     numleafsurfaces = CopyLump( header, LUMP_LEAFSURFACES, dleafsurfaces, sizeof(dleafsurfaces[0]) );
  200.     numleafbrushes = CopyLump( header, LUMP_LEAFBRUSHES, dleafbrushes, sizeof(dleafbrushes[0]) );
  201.     numbrushes = CopyLump( header, LUMP_BRUSHES, dbrushes, sizeof(dbrush_t) );
  202.     numbrushsides = CopyLump( header, LUMP_BRUSHSIDES, dbrushsides, sizeof(dbrushside_t) );
  203.     numDrawVerts = CopyLump( header, LUMP_DRAWVERTS, drawVerts, sizeof(drawVert_t) );
  204.     numDrawSurfaces = CopyLump( header, LUMP_SURFACES, drawSurfaces, sizeof(dsurface_t) );
  205.     numFogs = CopyLump( header, LUMP_FOGS, dfogs, sizeof(dfog_t) );
  206.     numDrawIndexes = CopyLump( header, LUMP_DRAWINDEXES, drawIndexes, sizeof(drawIndexes[0]) );
  207.  
  208.     numVisBytes = CopyLump( header, LUMP_VISIBILITY, visBytes, 1 );
  209.     numLightBytes = CopyLump( header, LUMP_LIGHTMAPS, lightBytes, 1 );
  210.     entdatasize = CopyLump( header, LUMP_ENTITIES, dentdata, 1);
  211.  
  212.     numGridPoints = CopyLump( header, LUMP_LIGHTGRID, gridData, 8 );
  213.  
  214.  
  215.     free( header );        // everything has been copied out
  216.         
  217.     // swap everything
  218.     SwapBSPFile();
  219. }
  220.  
  221.  
  222. //============================================================================
  223.  
  224. /*
  225. =============
  226. AddLump
  227. =============
  228. */
  229. void AddLump( FILE *bspfile, dheader_t *header, int lumpnum, const void *data, int len ) {
  230.     lump_t *lump;
  231.  
  232.     lump = &header->lumps[lumpnum];
  233.     
  234.     lump->fileofs = LittleLong( ftell(bspfile) );
  235.     lump->filelen = LittleLong( len );
  236.     SafeWrite( bspfile, data, (len+3)&~3 );
  237. }
  238.  
  239. /*
  240. =============
  241. WriteBSPFile
  242.  
  243. Swaps the bsp file in place, so it should not be referenced again
  244. =============
  245. */
  246. void    WriteBSPFile( const char *filename ) {        
  247.     dheader_t    outheader, *header;
  248.     FILE        *bspfile;
  249.  
  250.     header = &outheader;
  251.     memset( header, 0, sizeof(dheader_t) );
  252.     
  253.     SwapBSPFile();
  254.  
  255.     header->ident = LittleLong( BSP_IDENT );
  256.     header->version = LittleLong( BSP_VERSION );
  257.     
  258.     bspfile = SafeOpenWrite( filename );
  259.     SafeWrite( bspfile, header, sizeof(dheader_t) );    // overwritten later
  260.  
  261.     AddLump( bspfile, header, LUMP_SHADERS, dshaders, numShaders*sizeof(dshader_t) );
  262.     AddLump( bspfile, header, LUMP_PLANES, dplanes, numplanes*sizeof(dplane_t) );
  263.     AddLump( bspfile, header, LUMP_LEAFS, dleafs, numleafs*sizeof(dleaf_t) );
  264.     AddLump( bspfile, header, LUMP_NODES, dnodes, numnodes*sizeof(dnode_t) );
  265.     AddLump( bspfile, header, LUMP_BRUSHES, dbrushes, numbrushes*sizeof(dbrush_t) );
  266.     AddLump( bspfile, header, LUMP_BRUSHSIDES, dbrushsides, numbrushsides*sizeof(dbrushside_t) );
  267.     AddLump( bspfile, header, LUMP_LEAFSURFACES, dleafsurfaces, numleafsurfaces*sizeof(dleafsurfaces[0]) );
  268.     AddLump( bspfile, header, LUMP_LEAFBRUSHES, dleafbrushes, numleafbrushes*sizeof(dleafbrushes[0]) );
  269.     AddLump( bspfile, header, LUMP_MODELS, dmodels, nummodels*sizeof(dmodel_t) );
  270.     AddLump( bspfile, header, LUMP_DRAWVERTS, drawVerts, numDrawVerts*sizeof(drawVert_t) );
  271.     AddLump( bspfile, header, LUMP_SURFACES, drawSurfaces, numDrawSurfaces*sizeof(dsurface_t) );
  272.     AddLump( bspfile, header, LUMP_VISIBILITY, visBytes, numVisBytes );
  273.     AddLump( bspfile, header, LUMP_LIGHTMAPS, lightBytes, numLightBytes );
  274.     AddLump( bspfile, header, LUMP_LIGHTGRID, gridData, 8 * numGridPoints );
  275.     AddLump( bspfile, header, LUMP_ENTITIES, dentdata, entdatasize );
  276.     AddLump( bspfile, header, LUMP_FOGS, dfogs, numFogs * sizeof(dfog_t) );
  277.     AddLump( bspfile, header, LUMP_DRAWINDEXES, drawIndexes, numDrawIndexes * sizeof(drawIndexes[0]) );
  278.     
  279.     fseek (bspfile, 0, SEEK_SET);
  280.     SafeWrite (bspfile, header, sizeof(dheader_t));
  281.     fclose (bspfile);    
  282. }
  283.  
  284. //============================================================================
  285.  
  286. /*
  287. =============
  288. PrintBSPFileSizes
  289.  
  290. Dumps info about current file
  291. =============
  292. */
  293. void PrintBSPFileSizes( void ) {
  294.     if ( !num_entities ) {
  295.         ParseEntities();
  296.     }
  297.  
  298.     printf ("%6i models       %7i\n"
  299.         ,nummodels, (int)(nummodels*sizeof(dmodel_t)));
  300.     printf ("%6i shaders      %7i\n"
  301.         ,numShaders, (int)(numShaders*sizeof(dshader_t)));
  302.     printf ("%6i brushes      %7i\n"
  303.         ,numbrushes, (int)(numbrushes*sizeof(dbrush_t)));
  304.     printf ("%6i brushsides   %7i\n"
  305.         ,numbrushsides, (int)(numbrushsides*sizeof(dbrushside_t)));
  306.     printf ("%6i fogs         %7i\n"
  307.         ,numFogs, (int)(numFogs*sizeof(dfog_t)));
  308.     printf ("%6i planes       %7i\n"
  309.         ,numplanes, (int)(numplanes*sizeof(dplane_t)));
  310.     printf ("%6i entdata      %7i\n", num_entities, entdatasize);
  311.  
  312.     printf ("\n");
  313.  
  314.     printf ("%6i nodes        %7i\n"
  315.         ,numnodes, (int)(numnodes*sizeof(dnode_t)));
  316.     printf ("%6i leafs        %7i\n"
  317.         ,numleafs, (int)(numleafs*sizeof(dleaf_t)));
  318.     printf ("%6i leafsurfaces %7i\n"
  319.         ,numleafsurfaces, (int)(numleafsurfaces*sizeof(dleafsurfaces[0])));
  320.     printf ("%6i leafbrushes  %7i\n"
  321.         ,numleafbrushes, (int)(numleafbrushes*sizeof(dleafbrushes[0])));
  322.     printf ("%6i drawverts    %7i\n"
  323.         ,numDrawVerts, (int)(numDrawVerts*sizeof(drawVerts[0])));
  324.     printf ("%6i drawindexes  %7i\n"
  325.         ,numDrawIndexes, (int)(numDrawIndexes*sizeof(drawIndexes[0])));
  326.     printf ("%6i drawsurfaces %7i\n"
  327.         ,numDrawSurfaces, (int)(numDrawSurfaces*sizeof(drawSurfaces[0])));
  328.  
  329.     printf ("%6i lightmaps    %7i\n"
  330.         ,numLightBytes / (LIGHTMAP_WIDTH*LIGHTMAP_HEIGHT*3), numLightBytes );
  331.     printf ("       visibility   %7i\n"
  332.         , numVisBytes );
  333. }
  334.  
  335.  
  336. //============================================
  337.  
  338. int            num_entities;
  339. entity_t    entities[MAX_MAP_ENTITIES];
  340.  
  341. void StripTrailing( char *e ) {
  342.     char    *s;
  343.  
  344.     s = e + strlen(e)-1;
  345.     while (s >= e && *s <= 32)
  346.     {
  347.         *s = 0;
  348.         s--;
  349.     }
  350. }
  351.  
  352. /*
  353. =================
  354. ParseEpair
  355. =================
  356. */
  357. epair_t *ParseEpair( void ) {
  358.     epair_t    *e;
  359.  
  360.     e = malloc( sizeof(epair_t) );
  361.     memset( e, 0, sizeof(epair_t) );
  362.     
  363.     if ( strlen(token) >= MAX_KEY-1 ) {
  364.         Error ("ParseEpar: token too long");
  365.     }
  366.     e->key = copystring( token );
  367.     GetToken( qfalse );
  368.     if ( strlen(token) >= MAX_VALUE-1 ) {
  369.         Error ("ParseEpar: token too long");
  370.     }
  371.     e->value = copystring( token );
  372.  
  373.     // strip trailing spaces that sometimes get accidentally
  374.     // added in the editor
  375.     StripTrailing( e->key );
  376.     StripTrailing( e->value );
  377.  
  378.     return e;
  379. }
  380.  
  381.  
  382. /*
  383. ================
  384. ParseEntity
  385. ================
  386. */
  387. qboolean    ParseEntity( void ) {
  388.     epair_t        *e;
  389.     entity_t    *mapent;
  390.  
  391.     if ( !GetToken (qtrue) ) {
  392.         return qfalse;
  393.     }
  394.  
  395.     if ( strcmp (token, "{") ) {
  396.         Error ("ParseEntity: { not found");
  397.     }
  398.     if ( num_entities == MAX_MAP_ENTITIES ) {
  399.         Error ("num_entities == MAX_MAP_ENTITIES");
  400.     }
  401.     mapent = &entities[num_entities];
  402.     num_entities++;
  403.  
  404.     do {
  405.         if ( !GetToken (qtrue) ) {
  406.             Error ("ParseEntity: EOF without closing brace");
  407.         }
  408.         if ( !strcmp (token, "}") ) {
  409.             break;
  410.         }
  411.         e = ParseEpair ();
  412.         e->next = mapent->epairs;
  413.         mapent->epairs = e;
  414.     } while (1);
  415.     
  416.     return qtrue;
  417. }
  418.  
  419. /*
  420. ================
  421. ParseEntities
  422.  
  423. Parses the dentdata string into entities
  424. ================
  425. */
  426. void ParseEntities( void ) {
  427.     num_entities = 0;
  428.     ParseFromMemory( dentdata, entdatasize );
  429.  
  430.     while ( ParseEntity () ) {
  431.     }    
  432. }
  433.  
  434.  
  435. /*
  436. ================
  437. UnparseEntities
  438.  
  439. Generates the dentdata string from all the entities
  440. This allows the utilities to add or remove key/value pairs
  441. to the data created by the map editor.
  442. ================
  443. */
  444. void UnparseEntities( void ) {
  445.     char    *buf, *end;
  446.     epair_t    *ep;
  447.     char    line[2048];
  448.     int        i;
  449.     char    key[1024], value[1024];
  450.  
  451.     buf = dentdata;
  452.     end = buf;
  453.     *end = 0;
  454.     
  455.     for (i=0 ; i<num_entities ; i++) {
  456.         ep = entities[i].epairs;
  457.         if ( !ep ) {
  458.             continue;    // ent got removed
  459.         }
  460.         
  461.         strcat (end,"{\n");
  462.         end += 2;
  463.                 
  464.         for ( ep = entities[i].epairs ; ep ; ep=ep->next ) {
  465.             strcpy (key, ep->key);
  466.             StripTrailing (key);
  467.             strcpy (value, ep->value);
  468.             StripTrailing (value);
  469.                 
  470.             sprintf (line, "\"%s\" \"%s\"\n", key, value);
  471.             strcat (end, line);
  472.             end += strlen(line);
  473.         }
  474.         strcat (end,"}\n");
  475.         end += 2;
  476.  
  477.         if (end > buf + MAX_MAP_ENTSTRING) {
  478.             Error ("Entity text too long");
  479.         }
  480.     }
  481.     entdatasize = end - buf + 1;
  482. }
  483.  
  484. void PrintEntity( const entity_t *ent ) {
  485.     epair_t    *ep;
  486.     
  487.     printf ("------- entity %p -------\n", ent);
  488.     for (ep=ent->epairs ; ep ; ep=ep->next) {
  489.         printf( "%s = %s\n", ep->key, ep->value );
  490.     }
  491.  
  492. }
  493.  
  494. void     SetKeyValue( entity_t *ent, const char *key, const char *value ) {
  495.     epair_t    *ep;
  496.     
  497.     for ( ep=ent->epairs ; ep ; ep=ep->next ) {
  498.         if ( !strcmp (ep->key, key) ) {
  499.             free (ep->value);
  500.             ep->value = copystring(value);
  501.             return;
  502.         }
  503.     }
  504.     ep = malloc (sizeof(*ep));
  505.     ep->next = ent->epairs;
  506.     ent->epairs = ep;
  507.     ep->key = copystring(key);
  508.     ep->value = copystring(value);
  509. }
  510.  
  511. const char     *ValueForKey( const entity_t *ent, const char *key ) {
  512.     epair_t    *ep;
  513.     
  514.     for (ep=ent->epairs ; ep ; ep=ep->next) {
  515.         if (!strcmp (ep->key, key) ) {
  516.             return ep->value;
  517.         }
  518.     }
  519.     return "";
  520. }
  521.  
  522. vec_t    FloatForKey( const entity_t *ent, const char *key ) {
  523.     const char    *k;
  524.     
  525.     k = ValueForKey( ent, key );
  526.     return atof(k);
  527. }
  528.  
  529. void     GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec ) {
  530.     const char    *k;
  531.     double    v1, v2, v3;
  532.  
  533.     k = ValueForKey (ent, key);
  534.  
  535.     // scanf into doubles, then assign, so it is vec_t size independent
  536.     v1 = v2 = v3 = 0;
  537.     sscanf (k, "%lf %lf %lf", &v1, &v2, &v3);
  538.     vec[0] = v1;
  539.     vec[1] = v2;
  540.     vec[2] = v3;
  541. }
  542.  
  543.  
  544.